home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Modules / socketmodule.c < prev    next >
Text File  |  1996-02-08  |  38KB  |  1,512 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Socket module */
  26.  
  27. /*
  28. This module provides an interface to Berkeley socket IPC.
  29.  
  30. Limitations:
  31.  
  32. - only AF_INET and AF_UNIX address families are supported
  33. - no read/write operations (use send/recv or makefile instead)
  34.  
  35. Module interface:
  36.  
  37. - socket.error: exception raised for socket specific errors
  38. - socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
  39. - socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
  40. - socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
  41. - socket.getservbyname(servicename, protocolname) --> port number
  42. - socket.socket(family, type [, proto]) --> new socket object
  43. - socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
  44. - an Internet socket address is a pair (hostname, port)
  45.   where hostname can be anything recognized by gethostbyname()
  46.   (including the dd.dd.dd.dd notation) and port is in host byte order
  47. - where a hostname is returned, the dd.dd.dd.dd notation is used
  48. - a UNIX domain socket address is a string specifying the pathname
  49.  
  50. Socket methods:
  51.  
  52. - s.accept() --> new socket object, sockaddr
  53. - s.bind(sockaddr) --> None
  54. - s.close() --> None
  55. - s.connect(sockaddr) --> None
  56. - s.fileno() --> file descriptor
  57. - s.getpeername() --> sockaddr
  58. - s.getsockname() --> sockaddr
  59. - s.getsockopt(level, optname[, buflen]) --> int or string
  60. - s.listen(backlog) --> None
  61. - s.makefile([mode[, bufsize]]) --> file object
  62. - s.recv(buflen [,flags]) --> string
  63. - s.recvfrom(buflen [,flags]) --> string, sockaddr
  64. - s.send(string [,flags]) --> nbytes
  65. - s.sendto(string, [flags,] sockaddr) --> nbytes
  66. - s.setblocking(0 | 1) --> None
  67. - s.setsockopt(level, optname, value) --> None
  68. - s.shutdown(how) --> None
  69. - repr(s) --> "<socket object, fd=%d, family=%d, type=%d, protocol=%d>"
  70.  
  71. */
  72.  
  73. #include "Python.h"
  74.  
  75. #include <sys/types.h>
  76. #include "mytime.h"
  77.  
  78. #include <signal.h>
  79. #ifndef NT
  80. #include <netdb.h>
  81. #include <sys/socket.h>
  82. #include <netinet/in.h>
  83. #include <fcntl.h>
  84. #else
  85. #include <winsock.h>
  86. #include <fcntl.h>
  87. #endif
  88. #ifdef HAVE_SYS_UN_H
  89. #include <sys/un.h>
  90. #else
  91. #undef AF_UNIX
  92. #endif
  93.  
  94. #ifndef O_NDELAY
  95. #define O_NDELAY O_NONBLOCK    /* For QNX only? */
  96. #endif
  97.  
  98. #ifdef USE_GUSI
  99. /* fdopen() isn't declared in stdio.h (sigh) */
  100. #include <GUSI.h>
  101. #endif
  102.  
  103.  
  104. /* Here we have some hacks to choose between K&R or ANSI style function
  105.    definitions.  For NT to build this as an extension module (ie, DLL)
  106.    it must be compiled by the C++ compiler, as it takes the address of
  107.    a static data item exported from the main Python DLL.
  108. */
  109. #ifdef NT
  110. /* seem to be a few differences in the API */
  111. #define close closesocket
  112. #define NO_DUP    /* Define for NT 3.1, Win3.1 and Win95, Undefine for NT3.5 */
  113. #define FORCE_ANSI_FUNC_DEFS
  114. #endif
  115.  
  116. #ifdef FORCE_ANSI_FUNC_DEFS
  117. #define BUILD_FUNC_DEF_1( fnname, arg1type, arg1name )    \
  118. fnname( arg1type arg1name )
  119.  
  120. #define BUILD_FUNC_DEF_2( fnname, arg1type, arg1name, arg2type, arg2name ) \
  121. fnname( arg1type arg1name, arg2type arg2name )
  122.  
  123. #define BUILD_FUNC_DEF_3( fnname, arg1type, arg1name, arg2type, arg2name , arg3type, arg3name )    \
  124. fnname( arg1type arg1name, arg2type arg2name, arg3type arg3name )
  125.  
  126. #define BUILD_FUNC_DEF_4( fnname, arg1type, arg1name, arg2type, arg2name , arg3type, arg3name, arg4type, arg4name )    \
  127. fnname( arg1type arg1name, arg2type arg2name, arg3type arg3name, arg4type arg4name )
  128.  
  129. #else /* !FORCE_ANSI_FN_DEFS */
  130. #define BUILD_FUNC_DEF_1( fnname, arg1type, arg1name )    \
  131. fnname( arg1name )    \
  132.     arg1type arg1name;
  133.  
  134. #define BUILD_FUNC_DEF_2( fnname, arg1type, arg1name, arg2type, arg2name ) \
  135. fnname( arg1name, arg2name )    \
  136.     arg1type arg1name;    \
  137.     arg2type arg2name;
  138.  
  139. #define BUILD_FUNC_DEF_3( fnname, arg1type, arg1name, arg2type, arg2name, arg3type, arg3name ) \
  140. fnname( arg1name, arg2name, arg3name )    \
  141.     arg1type arg1name;    \
  142.     arg2type arg2name;    \
  143.     arg3type arg3name;
  144.  
  145. #define BUILD_FUNC_DEF_4( fnname, arg1type, arg1name, arg2type, arg2name, arg3type, arg3name, arg4type, arg4name ) \
  146. fnname( arg1name, arg2name, arg3name, arg4name )    \
  147.     arg1type arg1name;    \
  148.     arg2type arg2name;    \
  149.     arg3type arg3name;    \
  150.     arg4type arg4name;
  151.  
  152. #endif /* !FORCE_ANSI_FN_DEFS */
  153.  
  154. /* Global variable holding the exception type for errors detected
  155.    by this module (but not argument type or memory errors, etc.). */
  156.  
  157. static PyObject *PySocket_Error;
  158.  
  159.  
  160. /* Convenience function to raise an error according to errno
  161.    and return a NULL pointer from a function. */
  162.  
  163. static PyObject *
  164. PySocket_Err()
  165. {
  166. #ifdef NT
  167.     if (WSAGetLastError()) {
  168.         PyObject *v;
  169.         v = Py_BuildValue("(is)", WSAGetLastError(), "winsock error");
  170.         if (v != NULL) {
  171.             PyErr_SetObject(PySocket_Error, v);
  172.             Py_DECREF(v);
  173.         }
  174.         return NULL;
  175.     }
  176.     else
  177. #endif
  178.     return PyErr_SetFromErrno(PySocket_Error);
  179. }
  180.  
  181.  
  182. /* The object holding a socket.  It holds some extra information,
  183.    like the address family, which is used to decode socket address
  184.    arguments properly. */
  185.  
  186. typedef struct {
  187.     PyObject_HEAD
  188.     int sock_fd;        /* Socket file descriptor */
  189.     int sock_family;    /* Address family, e.g., AF_INET */
  190.     int sock_type;        /* Socket type, e.g., SOCK_STREAM */
  191.     int sock_proto;        /* Protocol type, usually 0 */
  192.     union sock_addr {
  193.         struct sockaddr_in in;
  194. #ifdef AF_UNIX
  195.         struct sockaddr_un un;
  196. #endif
  197.     } sock_addr;
  198. } PySocketSockObject;
  199.  
  200.  
  201. /* A forward reference to the Socktype type object.
  202.    The Socktype variable contains pointers to various functions,
  203.    some of which call newsockobject(), which uses Socktype, so
  204.    there has to be a circular reference. */
  205.  
  206. staticforward PyTypeObject PySocketSock_Type;
  207.  
  208.  
  209. /* Create a new socket object.
  210.    This just creates the object and initializes it.
  211.    If the creation fails, return NULL and set an exception (implicit
  212.    in NEWOBJ()). */
  213.  
  214. static PySocketSockObject *
  215. BUILD_FUNC_DEF_4(PySocketSock_New,int,fd, int,family, int,type, int,proto)
  216. {
  217.     PySocketSockObject *s;
  218.     s = PyObject_NEW(PySocketSockObject, &PySocketSock_Type);
  219.     if (s != NULL) {
  220.         s->sock_fd = fd;
  221.         s->sock_family = family;
  222.         s->sock_type = type;
  223.         s->sock_proto = proto;
  224.     }
  225.     return s;
  226. }
  227.  
  228.  
  229. /* Convert a string specifying a host name or one of a few symbolic
  230.    names to a numeric IP address.  This usually calls gethostbyname()
  231.    to do the work; the names "" and "<broadcast>" are special.
  232.    Return the length (should always be 4 bytes), or negative if
  233.    an error occurred; then an exception is raised. */
  234.  
  235. static int
  236. BUILD_FUNC_DEF_2(setipaddr, char*,name, struct sockaddr_in *,addr_ret)
  237. {
  238.     struct hostent *hp;
  239.     int d1, d2, d3, d4;
  240.     char ch;
  241. #ifdef HAVE_GETHOSTBYNAME_R
  242.     struct hostent hp_allocated;
  243.     char buf[1001];
  244.     int buf_len = (sizeof buf) - 1;
  245.     int errnop;
  246. #endif /* HAVE_GETHOSTBYNAME_R */
  247.  
  248.     if (name[0] == '\0') {
  249.         addr_ret->sin_addr.s_addr = INADDR_ANY;
  250.         return 4;
  251.     }
  252.     if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
  253.         addr_ret->sin_addr.s_addr = INADDR_BROADCAST;
  254.         return 4;
  255.     }
  256.     if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
  257.         0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
  258.         0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
  259.         addr_ret->sin_addr.s_addr = htonl(
  260.             ((long) d1 << 24) | ((long) d2 << 16) |
  261.             ((long) d3 << 8) | ((long) d4 << 0));
  262.         return 4;
  263.     }
  264. #ifdef HAVE_GETHOSTBYNAME_R
  265.     Py_BEGIN_ALLOW_THREADS
  266.     hp = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
  267.     Py_END_ALLOW_THREADS
  268. #else /* not HAVE_GETHOSTBYNAME_R */
  269.     hp = gethostbyname(name);
  270. #endif /* HAVE_GETHOSTBYNAME_R */
  271.  
  272.     if (hp == NULL) {
  273. #ifdef HAVE_HSTRERROR
  274.             /* Let's get real error message to return */
  275.             extern int h_errno;
  276.         PyErr_SetString(PySocket_Error, (char *)hstrerror(h_errno));
  277. #else
  278.         PyErr_SetString(PySocket_Error, "host not found");
  279. #endif
  280.         return -1;
  281.     }
  282.     memcpy((char *) &addr_ret->sin_addr, hp->h_addr, hp->h_length);
  283.     return hp->h_length;
  284. }
  285.  
  286.  
  287. /* Create a string object representing an IP address.
  288.    This is always a string of the form 'dd.dd.dd.dd' (with variable
  289.    size numbers). */
  290.  
  291. static PyObject *
  292. BUILD_FUNC_DEF_1(makeipaddr, struct sockaddr_in *,addr)
  293. {
  294.     long x = ntohl(addr->sin_addr.s_addr);
  295.     char buf[100];
  296.     sprintf(buf, "%d.%d.%d.%d",
  297.         (int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
  298.         (int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff);
  299.     return PyString_FromString(buf);
  300. }
  301.  
  302.  
  303. /* Create an object representing the given socket address,
  304.    suitable for passing it back to bind(), connect() etc.
  305.    The family field of the sockaddr structure is inspected
  306.    to determine what kind of address it really is. */
  307.  
  308. /*ARGSUSED*/
  309. static PyObject *
  310. BUILD_FUNC_DEF_2(makesockaddr,struct sockaddr *,addr, int,addrlen)
  311. {
  312.     if (addrlen == 0) {
  313.         /* No address -- may be recvfrom() from known socket */
  314.         Py_INCREF(Py_None);
  315.         return Py_None;
  316.     }
  317.  
  318.     switch (addr->sa_family) {
  319.  
  320.     case AF_INET:
  321.     {
  322.         struct sockaddr_in *a = (struct sockaddr_in *) addr;
  323.         PyObject *addr = makeipaddr(a);
  324.         PyObject *ret = Py_BuildValue("Oi", addr, ntohs(a->sin_port));
  325.         Py_XDECREF(addr);
  326.         return ret;
  327.     }
  328.  
  329. #ifdef AF_UNIX
  330.     case AF_UNIX:
  331.     {
  332.         struct sockaddr_un *a = (struct sockaddr_un *) addr;
  333.         return PyString_FromString(a->sun_path);
  334.     }
  335. #endif /* AF_UNIX */
  336.  
  337.     /* More cases here... */
  338.  
  339.     default:
  340.         PyErr_SetString(PySocket_Error, "return unknown socket address type");
  341.         return NULL;
  342.  
  343.     }
  344. }
  345.  
  346.  
  347. /* Parse a socket address argument according to the socket object's
  348.    address family.  Return 1 if the address was in the proper format,
  349.    0 of not.  The address is returned through addr_ret, its length
  350.    through len_ret. */
  351.  
  352. static int
  353. BUILD_FUNC_DEF_4(
  354. getsockaddrarg,PySocketSockObject *,s, PyObject *,args, struct sockaddr **,addr_ret, int *,len_ret)
  355. {
  356.     switch (s->sock_family) {
  357.  
  358. #ifdef AF_UNIX
  359.     case AF_UNIX:
  360.     {
  361.         struct sockaddr_un* addr;
  362.         char *path;
  363.         int len;
  364.         addr = (struct sockaddr_un* )&(s->sock_addr).un;
  365.         if (!PyArg_Parse(args, "s#", &path, &len))
  366.             return 0;
  367.         if (len > sizeof addr->sun_path) {
  368.             PyErr_SetString(PySocket_Error, "AF_UNIX path too long");
  369.             return 0;
  370.         }
  371.         addr->sun_family = AF_UNIX;
  372.         memcpy(addr->sun_path, path, len);
  373.         addr->sun_path[len] = 0;
  374.         *addr_ret = (struct sockaddr *) addr;
  375.         *len_ret = len + sizeof addr->sun_family;
  376.         return 1;
  377.     }
  378. #endif /* AF_UNIX */
  379.  
  380.     case AF_INET:
  381.     {
  382.         struct sockaddr_in* addr;
  383.         char *host;
  384.         int port;
  385.          addr=(struct sockaddr_in*)&(s->sock_addr).in;
  386.         if (!PyArg_Parse(args, "(si)", &host, &port))
  387.             return 0;
  388.         if (setipaddr(host, addr) < 0)
  389.             return 0;
  390.         addr->sin_family = AF_INET;
  391.         addr->sin_port = htons(port);
  392.         *addr_ret = (struct sockaddr *) addr;
  393.         *len_ret = sizeof *addr;
  394.         return 1;
  395.     }
  396.  
  397.     /* More cases here... */
  398.  
  399.     default:
  400.         PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
  401.         return 0;
  402.  
  403.     }
  404. }
  405.  
  406.  
  407. /* Get the address length according to the socket object's address family. 
  408.    Return 1 if the family is known, 0 otherwise.  The length is returned
  409.    through len_ret. */
  410.  
  411. static int
  412. BUILD_FUNC_DEF_2(getsockaddrlen,PySocketSockObject *,s, int *,len_ret)
  413. {
  414.     switch (s->sock_family) {
  415.  
  416. #ifdef AF_UNIX
  417.     case AF_UNIX:
  418.     {
  419.         *len_ret = sizeof (struct sockaddr_un);
  420.         return 1;
  421.     }
  422. #endif /* AF_UNIX */
  423.  
  424.     case AF_INET:
  425.     {
  426.         *len_ret = sizeof (struct sockaddr_in);
  427.         return 1;
  428.     }
  429.  
  430.     /* More cases here... */
  431.  
  432.     default:
  433.         PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
  434.         return 0;
  435.  
  436.     }
  437. }
  438.  
  439.  
  440. /* s.accept() method */
  441.  
  442. static PyObject *
  443. BUILD_FUNC_DEF_2(PySocketSock_accept,PySocketSockObject *,s, PyObject *,args)
  444. {
  445.     char addrbuf[256];
  446.     int addrlen, newfd;
  447.     PyObject *sock, *addr, *res;
  448.     if (!PyArg_NoArgs(args))
  449.         return NULL;
  450.     if (!getsockaddrlen(s, &addrlen))
  451.         return NULL;
  452.     Py_BEGIN_ALLOW_THREADS
  453.     newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
  454.     Py_END_ALLOW_THREADS
  455.     if (newfd < 0)
  456.         return PySocket_Err();
  457.     /* Create the new object with unspecified family,
  458.        to avoid calls to bind() etc. on it. */
  459.     sock = (PyObject *) PySocketSock_New(newfd,
  460.                     s->sock_family,
  461.                     s->sock_type,
  462.                     s->sock_proto);
  463.     if (sock == NULL)
  464.         close(newfd);
  465.     addr = makesockaddr((struct sockaddr *) addrbuf, addrlen);
  466.     res = Py_BuildValue("OO", sock, addr);
  467.     Py_XDECREF(sock);
  468.     Py_XDECREF(addr);
  469.     return res;
  470. }
  471.  
  472.  
  473. #if 0
  474. /* s.allowbroadcast() method */
  475. /* XXX obsolete -- will disappear in next release */
  476.  
  477. static PyObject *
  478. BUILD_FUNC_DEF_2(PySocketSock_allowbroadcast,PySocketSockObject *,s, PyObject *,args)
  479. {
  480.     int flag;
  481.     int res;
  482.     if (!PyArg_Parse(args, "i", &flag))
  483.         return NULL;
  484.     res = setsockopt(s->sock_fd, SOL_SOCKET, SO_BROADCAST,
  485.              (ANY *)&flag, sizeof flag);
  486.     if (res < 0)
  487.         return PySocket_Err();
  488.     Py_INCREF(Py_None);
  489.     return Py_None;
  490. }
  491. #endif
  492.  
  493.  
  494. /* s.setblocking(1 | 0) method */
  495.  
  496. static PyObject *
  497. BUILD_FUNC_DEF_2(PySocketSock_setblocking,PySocketSockObject*,s,PyObject*,args)
  498. {
  499.     int block;
  500.     int delay_flag;
  501.     if (!PyArg_GetInt(args, &block))
  502.         return NULL;
  503.     Py_BEGIN_ALLOW_THREADS
  504. #ifndef NT
  505.     delay_flag = fcntl (s->sock_fd, F_GETFL, 0);
  506.     if (block)
  507.         delay_flag &= (~O_NDELAY);
  508.     else
  509.         delay_flag |= O_NDELAY;
  510.     fcntl (s->sock_fd, F_SETFL, delay_flag);
  511. #else
  512.     block = !block;
  513.     ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
  514. #endif
  515.     Py_END_ALLOW_THREADS
  516.  
  517.     Py_INCREF(Py_None);
  518.     return Py_None;
  519. }
  520.  
  521.  
  522. /* s.setsockopt() method.
  523.    With an integer third argument, sets an integer option.
  524.    With a string third argument, sets an option from a buffer;
  525.    use optional built-in module 'struct' to encode the string. */
  526.  
  527. static PyObject *
  528. BUILD_FUNC_DEF_2(PySocketSock_setsockopt,PySocketSockObject *,s, PyObject *,args)
  529. {
  530.     int level;
  531.     int optname;
  532.     int res;
  533.     char *buf;
  534.     int buflen;
  535.     int flag;
  536.  
  537.     if (PyArg_Parse(args, "(iii)", &level, &optname, &flag)) {
  538.         buf = (char *) &flag;
  539.         buflen = sizeof flag;
  540.     }
  541.     else {
  542.         PyErr_Clear();
  543.         if (!PyArg_Parse(args, "(iis#)", &level, &optname, &buf, &buflen))
  544.             return NULL;
  545.     }
  546.     res = setsockopt(s->sock_fd, level, optname, (ANY *)buf, buflen);
  547.     if (res < 0)
  548.         return PySocket_Err();
  549.     Py_INCREF(Py_None);
  550.     return Py_None;
  551. }
  552.  
  553.  
  554. /* s.getsockopt() method.
  555.    With two arguments, retrieves an integer option.
  556.    With a third integer argument, retrieves a string buffer of that size;
  557.    use optional built-in module 'struct' to decode the string. */
  558.  
  559. static PyObject *
  560. BUILD_FUNC_DEF_2(PySocketSock_getsockopt,PySocketSockObject *,s, PyObject *,args)
  561. {
  562.     int level;
  563.     int optname;
  564.     int res;
  565.     PyObject *buf;
  566.     int buflen;
  567.     int flag;
  568.  
  569.     if (PyArg_Parse(args, "(ii)", &level, &optname)) {
  570.         int flag = 0;
  571.         int flagsize = sizeof flag;
  572.         res = getsockopt(s->sock_fd, level, optname,
  573.                  (ANY *)&flag, &flagsize);
  574.         if (res < 0)
  575.             return PySocket_Err();
  576.         return PyInt_FromLong(flag);
  577.     }
  578.     PyErr_Clear();
  579.     if (!PyArg_Parse(args, "(iii)", &level, &optname, &buflen))
  580.         return NULL;
  581.     if (buflen <= 0 || buflen > 1024) {
  582.         PyErr_SetString(PySocket_Error, "getsockopt buflen out of range");
  583.         return NULL;
  584.     }
  585.     buf = PyString_FromStringAndSize((char *)NULL, buflen);
  586.     if (buf == NULL)
  587.         return NULL;
  588.     res = getsockopt(s->sock_fd, level, optname,
  589.              (ANY *)PyString_AsString(buf), &buflen);
  590.     if (res < 0) {
  591.         Py_DECREF(buf);
  592.         return PySocket_Err();
  593.     }
  594.     _PyString_Resize(&buf, buflen);
  595.     return buf;
  596. }
  597.  
  598.  
  599. /* s.bind(sockaddr) method */
  600.  
  601. static PyObject *
  602. BUILD_FUNC_DEF_2(PySocketSock_bind,PySocketSockObject *,s, PyObject *,args)
  603. {
  604.     struct sockaddr *addr;
  605.     int addrlen;
  606.     int res;
  607.     if (!getsockaddrarg(s, args, &addr, &addrlen))
  608.         return NULL;
  609.     Py_BEGIN_ALLOW_THREADS
  610.     res = bind(s->sock_fd, addr, addrlen);
  611.     Py_END_ALLOW_THREADS
  612.     if (res < 0)
  613.         return PySocket_Err();
  614.     Py_INCREF(Py_None);
  615.     return Py_None;
  616. }
  617.  
  618.  
  619. /* s.close() method.
  620.    Set the file descriptor to -1 so operations tried subsequently
  621.    will surely fail. */
  622.  
  623. static PyObject *
  624. BUILD_FUNC_DEF_2(PySocketSock_close,PySocketSockObject *,s, PyObject *,args)
  625. {
  626.     if (!PyArg_NoArgs(args))
  627.         return NULL;
  628.     Py_BEGIN_ALLOW_THREADS
  629.     (void) close(s->sock_fd);
  630.     Py_END_ALLOW_THREADS
  631.     s->sock_fd = -1;
  632.     Py_INCREF(Py_None);
  633.     return Py_None;
  634. }
  635.  
  636.  
  637. /* s.connect(sockaddr) method */
  638.  
  639. static PyObject *
  640. BUILD_FUNC_DEF_2(PySocketSock_connect,PySocketSockObject *,s, PyObject *,args)
  641. {
  642.     struct sockaddr *addr;
  643.     int addrlen;
  644.     int res;
  645.     if (!getsockaddrarg(s, args, &addr, &addrlen))
  646.         return NULL;
  647.     Py_BEGIN_ALLOW_THREADS
  648.     res = connect(s->sock_fd, addr, addrlen);
  649.     Py_END_ALLOW_THREADS
  650.     if (res < 0)
  651.         return PySocket_Err();
  652.     Py_INCREF(Py_None);
  653.     return Py_None;
  654. }
  655.  
  656.  
  657. /* s.fileno() method */
  658.  
  659. static PyObject *
  660. BUILD_FUNC_DEF_2(PySocketSock_fileno,PySocketSockObject *,s, PyObject *,args)
  661. {
  662.     if (!PyArg_NoArgs(args))
  663.         return NULL;
  664.     return PyInt_FromLong((long) s->sock_fd);
  665. }
  666.  
  667.  
  668. /* s.getsockname() method */
  669.  
  670. static PyObject *
  671. BUILD_FUNC_DEF_2(PySocketSock_getsockname,PySocketSockObject *,s, PyObject *,args)
  672. {
  673.     char addrbuf[256];
  674.     int addrlen, res;
  675.     if (!PyArg_NoArgs(args))
  676.         return NULL;
  677.     if (!getsockaddrlen(s, &addrlen))
  678.         return NULL;
  679.     memset(addrbuf, 0, addrlen);
  680.     Py_BEGIN_ALLOW_THREADS
  681.     res = getsockname(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
  682.     Py_END_ALLOW_THREADS
  683.     if (res < 0)
  684.         return PySocket_Err();
  685.     return makesockaddr((struct sockaddr *) addrbuf, addrlen);
  686. }
  687.  
  688.  
  689. #ifdef HAVE_GETPEERNAME        /* Cray APP doesn't have this :-( */
  690. /* s.getpeername() method */
  691.  
  692. static PyObject *
  693. BUILD_FUNC_DEF_2(PySocketSock_getpeername,PySocketSockObject *,s, PyObject *,args)
  694. {
  695.     char addrbuf[256];
  696.     int addrlen, res;
  697.     if (!PyArg_NoArgs(args))
  698.         return NULL;
  699.     if (!getsockaddrlen(s, &addrlen))
  700.         return NULL;
  701.     Py_BEGIN_ALLOW_THREADS
  702.     res = getpeername(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
  703.     Py_END_ALLOW_THREADS
  704.     if (res < 0)
  705.         return PySocket_Err();
  706.     return makesockaddr((struct sockaddr *) addrbuf, addrlen);
  707. }
  708. #endif /* HAVE_GETPEERNAME */
  709.  
  710.  
  711. /* s.listen(n) method */
  712.  
  713. static PyObject *
  714. BUILD_FUNC_DEF_2(PySocketSock_listen,PySocketSockObject *,s, PyObject *,args)
  715. {
  716.     int backlog;
  717.     int res;
  718.     if (!PyArg_GetInt(args, &backlog))
  719.         return NULL;
  720.     Py_BEGIN_ALLOW_THREADS
  721.     if (backlog < 1)
  722.         backlog = 1;
  723.     res = listen(s->sock_fd, backlog);
  724.     Py_END_ALLOW_THREADS
  725.     if (res < 0)
  726.         return PySocket_Err();
  727.     Py_INCREF(Py_None);
  728.     return Py_None;
  729. }
  730.  
  731. #ifndef NO_DUP
  732. /* s.makefile(mode) method.
  733.    Create a new open file object referring to a dupped version of
  734.    the socket's file descriptor.  (The dup() call is necessary so
  735.    that the open file and socket objects may be closed independent
  736.    of each other.)
  737.    The mode argument specifies 'r' or 'w' passed to fdopen(). */
  738.  
  739. static PyObject *
  740. BUILD_FUNC_DEF_2(PySocketSock_makefile,PySocketSockObject *,s, PyObject *,args)
  741. {
  742.     extern int fclose Py_PROTO((FILE *));
  743.     char *mode = "r";
  744.     int bufsize = -1;
  745.     int fd;
  746.     FILE *fp;
  747.     PyObject *f;
  748.  
  749.     if (!PyArg_ParseTuple(args, "|si", &mode, &bufsize))
  750.         return NULL;
  751. #ifdef NT
  752.    if ( ((fd =  _open_osfhandle( s->sock_fd, _O_BINARY )) < 0) ||
  753.         ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL)) {
  754. #else
  755.     if ((fd = dup(s->sock_fd)) < 0 ||
  756.         (fp = fdopen(fd, mode)) == NULL) {
  757. #endif
  758.         if (fd >= 0)
  759.             close(fd);
  760.         return PySocket_Err();
  761.     }
  762.     f = PyFile_FromFile(fp, "<socket>", mode, fclose);
  763.     if (f != NULL)
  764.         PyFile_SetBufSize(f, bufsize);
  765.     return f;
  766. }
  767. #endif /* NO_DUP */
  768.  
  769. /* s.recv(nbytes [,flags]) method */
  770.  
  771. static PyObject *
  772. BUILD_FUNC_DEF_2(PySocketSock_recv,PySocketSockObject *,s, PyObject *,args)
  773. {
  774.     int len, n, flags;
  775.     PyObject *buf;
  776.     flags = 0;
  777.     if (!PyArg_Parse(args, "i", &len)) {
  778.         PyErr_Clear();
  779.         if (!PyArg_Parse(args, "(ii)", &len, &flags))
  780.             return NULL;
  781.     }
  782.     buf = PyString_FromStringAndSize((char *) 0, len);
  783.     if (buf == NULL)
  784.         return NULL;
  785.     Py_BEGIN_ALLOW_THREADS
  786.     n = recv(s->sock_fd, PyString_AsString(buf), len, flags);
  787.     Py_END_ALLOW_THREADS
  788.     if (n < 0) {
  789.         Py_DECREF(buf);
  790.         return PySocket_Err();
  791.     }
  792.     if (_PyString_Resize(&buf, n) < 0)
  793.         return NULL;
  794.     return buf;
  795. }
  796.  
  797.  
  798. /* s.recvfrom(nbytes [,flags]) method */
  799.  
  800. static PyObject *
  801. BUILD_FUNC_DEF_2(PySocketSock_recvfrom,PySocketSockObject *,s, PyObject *,args)
  802. {
  803.     char addrbuf[256];
  804.     PyObject *buf, *addr, *ret;
  805.     int addrlen, len, n, flags;
  806.     flags = 0;
  807.     if (!PyArg_Parse(args, "i", &len)) {
  808.         PyErr_Clear();
  809.         if (!PyArg_Parse(args, "(ii)", &len, &flags))
  810.             return NULL;
  811.     }
  812.     if (!getsockaddrlen(s, &addrlen))
  813.         return NULL;
  814.     buf = PyString_FromStringAndSize((char *) 0, len);
  815.     if (buf == NULL)
  816.         return NULL;
  817.     Py_BEGIN_ALLOW_THREADS
  818.     n = recvfrom(s->sock_fd, PyString_AsString(buf), len, flags,
  819. #ifndef NT
  820.              (ANY *)addrbuf, &addrlen);
  821. #else
  822.              (struct sockaddr *)addrbuf, &addrlen);
  823. #endif
  824.     Py_END_ALLOW_THREADS
  825.     if (n < 0) {
  826.         Py_DECREF(buf);
  827.         return PySocket_Err();
  828.     }
  829.     if (_PyString_Resize(&buf, n) < 0)
  830.         return NULL;
  831.     addr = makesockaddr((struct sockaddr *)addrbuf, addrlen);
  832.     ret = Py_BuildValue("OO", buf, addr);
  833.     Py_XDECREF(addr);
  834.     Py_XDECREF(buf);
  835.     return ret;
  836. }
  837.  
  838.  
  839. /* s.send(data [,flags]) method */
  840.  
  841. static PyObject *
  842. BUILD_FUNC_DEF_2(PySocketSock_send,PySocketSockObject *,s, PyObject *,args)
  843. {
  844.     char *buf;
  845.     int len, n, flags;
  846.     flags = 0;
  847.     if (!PyArg_Parse(args, "s#", &buf, &len)) {
  848.         PyErr_Clear();
  849.         if (!PyArg_Parse(args, "(s#i)", &buf, &len, &flags))
  850.             return NULL;
  851.     }
  852.     Py_BEGIN_ALLOW_THREADS
  853.     n = send(s->sock_fd, buf, len, flags);
  854.     Py_END_ALLOW_THREADS
  855.     if (n < 0)
  856.         return PySocket_Err();
  857.     return PyInt_FromLong((long)n);
  858. }
  859.  
  860.  
  861. /* s.sendto(data, [flags,] sockaddr) method */
  862.  
  863. static PyObject *
  864. BUILD_FUNC_DEF_2(PySocketSock_sendto,PySocketSockObject *,s, PyObject *,args)
  865. {
  866.     PyObject *addro;
  867.     char *buf;
  868.     struct sockaddr *addr;
  869.     int addrlen, len, n, flags;
  870.     flags = 0;
  871.     if (!PyArg_Parse(args, "(s#O)", &buf, &len, &addro)) {
  872.         PyErr_Clear();
  873.         if (!PyArg_Parse(args, "(s#iO)", &buf, &len, &flags, &addro))
  874.             return NULL;
  875.     }
  876.     if (!getsockaddrarg(s, addro, &addr, &addrlen))
  877.         return NULL;
  878.     Py_BEGIN_ALLOW_THREADS
  879.     n = sendto(s->sock_fd, buf, len, flags, addr, addrlen);
  880.     Py_END_ALLOW_THREADS
  881.     if (n < 0)
  882.         return PySocket_Err();
  883.     return PyInt_FromLong((long)n);
  884. }
  885.  
  886.  
  887. /* s.shutdown(how) method */
  888.  
  889. static PyObject *
  890. BUILD_FUNC_DEF_2(PySocketSock_shutdown,PySocketSockObject *,s, PyObject *,args)
  891. {
  892.     int how;
  893.     int res;
  894.     if (!PyArg_GetInt(args, &how))
  895.         return NULL;
  896.     Py_BEGIN_ALLOW_THREADS
  897.     res = shutdown(s->sock_fd, how);
  898.     Py_END_ALLOW_THREADS
  899.     if (res < 0)
  900.         return PySocket_Err();
  901.     Py_INCREF(Py_None);
  902.     return Py_None;
  903. }
  904.  
  905.  
  906. /* List of methods for socket objects */
  907.  
  908. static PyMethodDef PySocketSock_methods[] = {
  909.     {"accept",        (PyCFunction)PySocketSock_accept},
  910. #if 0
  911.     {"allowbroadcast",    (PyCFunction)PySocketSock_allowbroadcast},
  912. #endif
  913.     {"setblocking",        (PyCFunction)PySocketSock_setblocking},
  914.     {"setsockopt",        (PyCFunction)PySocketSock_setsockopt},
  915.     {"getsockopt",        (PyCFunction)PySocketSock_getsockopt},
  916.     {"bind",        (PyCFunction)PySocketSock_bind},
  917.     {"close",        (PyCFunction)PySocketSock_close},
  918.     {"connect",        (PyCFunction)PySocketSock_connect},
  919.     {"fileno",        (PyCFunction)PySocketSock_fileno},
  920.     {"getsockname",        (PyCFunction)PySocketSock_getsockname},
  921. #ifdef HAVE_GETPEERNAME
  922.     {"getpeername",        (PyCFunction)PySocketSock_getpeername},
  923. #endif
  924.     {"listen",        (PyCFunction)PySocketSock_listen},
  925. #ifndef NO_DUP
  926.     {"makefile",        (PyCFunction)PySocketSock_makefile, 1},
  927. #endif
  928.     {"recv",        (PyCFunction)PySocketSock_recv},
  929.     {"recvfrom",        (PyCFunction)PySocketSock_recvfrom},
  930.     {"send",        (PyCFunction)PySocketSock_send},
  931.     {"sendto",        (PyCFunction)PySocketSock_sendto},
  932.     {"shutdown",        (PyCFunction)PySocketSock_shutdown},
  933.     {NULL,            NULL}        /* sentinel */
  934. };
  935.  
  936.  
  937. /* Deallocate a socket object in response to the last Py_DECREF().
  938.    First close the file description. */
  939.  
  940. static void
  941. BUILD_FUNC_DEF_1(PySocketSock_dealloc,PySocketSockObject *,s)
  942. {
  943.     (void) close(s->sock_fd);
  944.     PyMem_DEL(s);
  945. }
  946.  
  947.  
  948. /* Return a socket object's named attribute. */
  949.  
  950. static PyObject *
  951. BUILD_FUNC_DEF_2(PySocketSock_getattr,PySocketSockObject *,s, char *,name)
  952. {
  953.     return Py_FindMethod(PySocketSock_methods, (PyObject *) s, name);
  954. }
  955.  
  956.  
  957. static PyObject *
  958. BUILD_FUNC_DEF_1(PySocketSock_repr,PySocketSockObject *,s)
  959. {
  960.     PyObject *addro;
  961.     struct sockaddr *addr;
  962.     char buf[512];
  963.     PyObject *t, *comma, *v;
  964.     int i, len;
  965.     sprintf(buf, 
  966.         "<socket object, fd=%d, family=%d, type=%d, protocol=%d>", 
  967.         s->sock_fd, s->sock_family, s->sock_type, s->sock_proto);
  968.     t = PyString_FromString(buf);
  969.     return t;
  970. }
  971.  
  972.  
  973. /* Type object for socket objects. */
  974.  
  975. static PyTypeObject PySocketSock_Type = {
  976.     PyObject_HEAD_INIT(&PyType_Type)
  977.     0,
  978.     "socket",
  979.     sizeof(PySocketSockObject),
  980.     0,
  981.     (destructor)PySocketSock_dealloc, /*tp_dealloc*/
  982.     0,        /*tp_print*/
  983.     (getattrfunc)PySocketSock_getattr, /*tp_getattr*/
  984.     0,        /*tp_setattr*/
  985.     0,        /*tp_compare*/
  986.     (reprfunc)PySocketSock_repr, /*tp_repr*/
  987.     0,        /*tp_as_number*/
  988.     0,        /*tp_as_sequence*/
  989.     0,        /*tp_as_mapping*/
  990. };
  991.  
  992.  
  993. /* Python interface to gethostname(). */
  994.  
  995. /*ARGSUSED*/
  996. static PyObject *
  997. BUILD_FUNC_DEF_2(PySocket_gethostname,PyObject *,self, PyObject *,args)
  998. {
  999.     char buf[1024];
  1000.     int res;
  1001.     if (!PyArg_NoArgs(args))
  1002.         return NULL;
  1003.     Py_BEGIN_ALLOW_THREADS
  1004.     res = gethostname(buf, (int) sizeof buf - 1);
  1005.     Py_END_ALLOW_THREADS
  1006.     if (res < 0)
  1007.         return PySocket_Err();
  1008.     buf[sizeof buf - 1] = '\0';
  1009.     return PyString_FromString(buf);
  1010. }
  1011.  
  1012.  
  1013. /* Python interface to gethostbyname(name). */
  1014.  
  1015. /*ARGSUSED*/
  1016. static PyObject *
  1017. BUILD_FUNC_DEF_2(PySocket_gethostbyname,PyObject *,self, PyObject *,args)
  1018. {
  1019.     char *name;
  1020.     struct sockaddr_in addrbuf;
  1021.     if (!PyArg_Parse(args, "s", &name))
  1022.         return NULL;
  1023.     if (setipaddr(name, &addrbuf) < 0)
  1024.         return NULL;
  1025.     return makeipaddr(&addrbuf);
  1026. }
  1027.  
  1028. /* Python interface to gethostbyaddr(IP). */
  1029.  
  1030. /*ARGSUSED*/
  1031. static PyObject *
  1032. BUILD_FUNC_DEF_2(PySocket_gethostbyaddr,PyObject *,self, PyObject *, args)
  1033. {
  1034.         struct sockaddr_in addr;
  1035.     char *ip_num;
  1036.     struct hostent *h;
  1037.     int d1,d2,d3,d4;
  1038.     char ch, **pch;
  1039.     PyObject *rtn_tuple = (PyObject *)NULL;
  1040.     PyObject *name_list = (PyObject *)NULL;
  1041.     PyObject *addr_list = (PyObject *)NULL;
  1042.     PyObject *tmp;
  1043.  
  1044.     if (!PyArg_Parse(args, "s", &ip_num))
  1045.         return NULL;
  1046.     if (setipaddr(ip_num, &addr) < 0)
  1047.         return NULL;
  1048.     h = gethostbyaddr((char *)&addr.sin_addr,
  1049.               sizeof(addr.sin_addr),
  1050.               AF_INET);
  1051.     if (h == NULL) {
  1052. #ifdef HAVE_HSTRERROR
  1053.             /* Let's get real error message to return */
  1054.             extern int h_errno;
  1055.         PyErr_SetString(PySocket_Error, (char *)hstrerror(h_errno));
  1056. #else
  1057.         PyErr_SetString(PySocket_Error, "host not found");
  1058. #endif
  1059.         return NULL;
  1060.     }
  1061.     if ((name_list = PyList_New(0)) == NULL)
  1062.         goto err;
  1063.     if ((addr_list = PyList_New(0)) == NULL)
  1064.         goto err;
  1065.     for (pch = h->h_aliases; *pch != NULL; pch++) {
  1066.         tmp = PyString_FromString(*pch);
  1067.         if (tmp == NULL)
  1068.             goto err;
  1069.         PyList_Append(name_list, tmp);
  1070.         Py_DECREF(tmp);
  1071.     }
  1072.     for (pch = h->h_addr_list; *pch != NULL; pch++) {
  1073.         memcpy((char *) &addr.sin_addr, *pch, h->h_length);
  1074.         tmp = makeipaddr(&addr);
  1075.         if (tmp == NULL)
  1076.             goto err;
  1077.         PyList_Append(addr_list, tmp);
  1078.         Py_DECREF(tmp);
  1079.     }
  1080.     rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
  1081.  err:
  1082.     Py_XDECREF(name_list);
  1083.     Py_XDECREF(addr_list);
  1084.     return rtn_tuple;
  1085. }
  1086.  
  1087.  
  1088. /* Python interface to getservbyname(name).
  1089.    This only returns the port number, since the other info is already
  1090.    known or not useful (like the list of aliases). */
  1091.  
  1092. /*ARGSUSED*/
  1093. static PyObject *
  1094. BUILD_FUNC_DEF_2(PySocket_getservbyname,PyObject *,self, PyObject *,args)
  1095. {
  1096.     char *name, *proto;
  1097.     struct servent *sp;
  1098.     if (!PyArg_Parse(args, "(ss)", &name, &proto))
  1099.         return NULL;
  1100.     Py_BEGIN_ALLOW_THREADS
  1101.     sp = getservbyname(name, proto);
  1102.     Py_END_ALLOW_THREADS
  1103.     if (sp == NULL) {
  1104.         PyErr_SetString(PySocket_Error, "service/proto not found");
  1105.         return NULL;
  1106.     }
  1107.     return PyInt_FromLong((long) ntohs(sp->s_port));
  1108. }
  1109.  
  1110.  
  1111. /* Python interface to socket(family, type, proto).
  1112.    The third (protocol) argument is optional.
  1113.    Return a new socket object. */
  1114.  
  1115. /*ARGSUSED*/
  1116. static PyObject *
  1117. BUILD_FUNC_DEF_2(PySocket_socket,PyObject *,self, PyObject *,args)
  1118. {
  1119.     PySocketSockObject *s;
  1120.     int fd, family, type, proto;
  1121.     proto = 0;
  1122.     if (!PyArg_Parse(args, "(ii)", &family, &type)) {
  1123.         PyErr_Clear();
  1124.         if (!PyArg_Parse(args, "(iii)", &family, &type, &proto))
  1125.             return NULL;
  1126.     }
  1127.     Py_BEGIN_ALLOW_THREADS
  1128.     fd = socket(family, type, proto);
  1129.     Py_END_ALLOW_THREADS
  1130.     if (fd < 0)
  1131.         return PySocket_Err();
  1132.     s = PySocketSock_New(fd, family, type, proto);
  1133.     /* If the object can't be created, don't forget to close the
  1134.        file descriptor again! */
  1135.     if (s == NULL)
  1136.         (void) close(fd);
  1137.     /* From now on, ignore SIGPIPE and let the error checking
  1138.        do the work. */
  1139. #ifdef SIGPIPE      
  1140.     (void) signal(SIGPIPE, SIG_IGN);
  1141. #endif   
  1142.     return (PyObject *) s;
  1143. }
  1144.  
  1145. #ifndef NO_DUP
  1146. /* Create a socket object from a numeric file description.
  1147.    Useful e.g. if stdin is a socket.
  1148.    Additional arguments as for socket(). */
  1149.  
  1150. /*ARGSUSED*/
  1151. static PyObject *
  1152. BUILD_FUNC_DEF_2(PySocket_fromfd,PyObject *,self, PyObject *,args)
  1153. {
  1154.     PySocketSockObject *s;
  1155.     int fd, family, type, proto;
  1156.     proto = 0;
  1157.     if (!PyArg_Parse(args, "(iii)", &fd, &family, &type)) {
  1158.         PyErr_Clear();
  1159.         if (!PyArg_Parse(args, "(iiii)", &fd, &family, &type, &proto))
  1160.             return NULL;
  1161.     }
  1162.     /* Dup the fd so it and the socket can be closed independently */
  1163.     fd = dup(fd);
  1164.     if (fd < 0)
  1165.         return PySocket_Err();
  1166.     s = PySocketSock_New(fd, family, type, proto);
  1167.     /* From now on, ignore SIGPIPE and let the error checking
  1168.        do the work. */
  1169. #ifdef SIGPIPE      
  1170.     (void) signal(SIGPIPE, SIG_IGN);
  1171. #endif   
  1172.     return (PyObject *) s;
  1173. }
  1174. #endif /* NO_DUP */
  1175.  
  1176. /* List of functions exported by this module. */
  1177.  
  1178. static PyMethodDef PySocket_methods[] = {
  1179.     {"gethostbyname",    PySocket_gethostbyname},
  1180.     {"gethostbyaddr",    PySocket_gethostbyaddr},
  1181.     {"gethostname",        PySocket_gethostname},
  1182.     {"getservbyname",    PySocket_getservbyname},
  1183.     {"socket",        PySocket_socket},
  1184. #ifndef NO_DUP
  1185.     {"fromfd",        PySocket_fromfd},
  1186. #endif
  1187.     {NULL,            NULL}         /* Sentinel */
  1188. };
  1189.  
  1190.  
  1191. /* Convenience routine to export an integer value.
  1192.    For simplicity, errors (which are unlikely anyway) are ignored. */
  1193.  
  1194. static void
  1195. BUILD_FUNC_DEF_3(insint,PyObject *,d, char *,name, int,value)
  1196. {
  1197.     PyObject *v = PyInt_FromLong((long) value);
  1198.     if (v == NULL) {
  1199.         /* Don't bother reporting this error */
  1200.         PyErr_Clear();
  1201.     }
  1202.     else {
  1203.         PyDict_SetItemString(d, name, v);
  1204.         Py_DECREF(v);
  1205.     }
  1206. }
  1207.  
  1208.  
  1209. /* Initialize this module.
  1210.    This is called when the first 'import socket' is done,
  1211.    via a table in config.c, if config.c is compiled with USE_SOCKET
  1212.    defined. */
  1213.  
  1214. void
  1215. initsocket()
  1216. {
  1217.     PyObject *m, *d;
  1218.     m = Py_InitModule("socket", PySocket_methods);
  1219.     d = PyModule_GetDict(m);
  1220.     PySocket_Error = PyString_FromString("socket.error");
  1221.     if (PySocket_Error == NULL || 
  1222.         PyDict_SetItemString(d, "error", PySocket_Error) != 0)
  1223.         Py_FatalError("can't define socket.error");
  1224.     insint(d, "AF_INET", AF_INET);
  1225. #ifdef AF_UNIX
  1226.     insint(d, "AF_UNIX", AF_UNIX);
  1227. #endif /* AF_UNIX */
  1228.     insint(d, "SOCK_STREAM", SOCK_STREAM);
  1229.     insint(d, "SOCK_DGRAM", SOCK_DGRAM);
  1230.     insint(d, "SOCK_RAW", SOCK_RAW);
  1231.     insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
  1232.     insint(d, "SOCK_RDM", SOCK_RDM);
  1233.  
  1234. #ifdef    SO_DEBUG
  1235.     insint(d, "SO_DEBUG", SO_DEBUG);
  1236. #endif
  1237. #ifdef    SO_ACCEPTCONN
  1238.     insint(d, "SO_ACCEPTCONN", SO_ACCEPTCONN);
  1239. #endif
  1240. #ifdef    SO_REUSEADDR
  1241.     insint(d, "SO_REUSEADDR", SO_REUSEADDR);
  1242. #endif
  1243. #ifdef    SO_KEEPALIVE
  1244.     insint(d, "SO_KEEPALIVE", SO_KEEPALIVE);
  1245. #endif
  1246. #ifdef    SO_DONTROUTE
  1247.     insint(d, "SO_DONTROUTE", SO_DONTROUTE);
  1248. #endif
  1249. #ifdef    SO_BROADCAST
  1250.     insint(d, "SO_BROADCAST", SO_BROADCAST);
  1251. #endif
  1252. #ifdef    SO_USELOOPBACK
  1253.     insint(d, "SO_USELOOPBACK", SO_USELOOPBACK);
  1254. #endif
  1255. #ifdef    SO_LINGER
  1256.     insint(d, "SO_LINGER", SO_LINGER);
  1257. #endif
  1258. #ifdef    SO_OOBINLINE
  1259.     insint(d, "SO_OOBINLINE", SO_OOBINLINE);
  1260. #endif
  1261. #ifdef    SO_REUSEPORT
  1262.     insint(d, "SO_REUSEPORT", SO_REUSEPORT);
  1263. #endif
  1264.  
  1265. #ifdef    SO_SNDBUF
  1266.     insint(d, "SO_SNDBUF", SO_SNDBUF);
  1267. #endif
  1268. #ifdef    SO_RCVBUF
  1269.     insint(d, "SO_RCVBUF", SO_RCVBUF);
  1270. #endif
  1271. #ifdef    SO_SNDLOWAT
  1272.     insint(d, "SO_SNDLOWAT", SO_SNDLOWAT);
  1273. #endif
  1274. #ifdef    SO_RCVLOWAT
  1275.     insint(d, "SO_RCVLOWAT", SO_RCVLOWAT);
  1276. #endif
  1277. #ifdef    SO_SNDTIMEO
  1278.     insint(d, "SO_SNDTIMEO", SO_SNDTIMEO);
  1279. #endif
  1280. #ifdef    SO_RCVTIMEO
  1281.     insint(d, "SO_RCVTIMEO", SO_RCVTIMEO);
  1282. #endif
  1283. #ifdef    SO_ERROR
  1284.     insint(d, "SO_ERROR", SO_ERROR);
  1285. #endif
  1286. #ifdef    SO_TYPE
  1287.     insint(d, "SO_TYPE", SO_TYPE);
  1288. #endif
  1289.  
  1290.     /* Maximum number of connections for "listen" */
  1291. #ifdef    SOMAXCONN
  1292.     insint(d, "SOMAXCONN", SOMAXCONN);
  1293. #else
  1294.     insint(d, "SOMAXCONN", 5);    /* Common value */
  1295. #endif
  1296.  
  1297.     /* Flags for send, recv */
  1298. #ifdef    MSG_OOB
  1299.     insint(d, "MSG_OOB", MSG_OOB);
  1300. #endif
  1301. #ifdef    MSG_PEEK
  1302.     insint(d, "MSG_PEEK", MSG_PEEK);
  1303. #endif
  1304. #ifdef    MSG_DONTROUTE
  1305.     insint(d, "MSG_DONTROUTE", MSG_DONTROUTE);
  1306. #endif
  1307. #ifdef    MSG_EOR
  1308.     insint(d, "MSG_EOR", MSG_EOR);
  1309. #endif
  1310. #ifdef    MSG_TRUNC
  1311.     insint(d, "MSG_TRUNC", MSG_TRUNC);
  1312. #endif
  1313. #ifdef    MSG_CTRUNC
  1314.     insint(d, "MSG_CTRUNC", MSG_CTRUNC);
  1315. #endif
  1316. #ifdef    MSG_WAITALL
  1317.     insint(d, "MSG_WAITALL", MSG_WAITALL);
  1318. #endif
  1319. #ifdef    MSG_BTAG
  1320.     insint(d, "MSG_BTAG", MSG_BTAG);
  1321. #endif
  1322. #ifdef    MSG_ETAG
  1323.     insint(d, "MSG_ETAG", MSG_ETAG);
  1324. #endif
  1325.  
  1326.     /* Protocol level and numbers, usable for [gs]etsockopt */
  1327. #ifdef    SOL_SOCKET
  1328.     insint(d, "SOL_SOCKET", SOL_SOCKET);
  1329. #endif
  1330. #ifdef    IPPROTO_IP
  1331.     insint(d, "IPPROTO_IP", IPPROTO_IP);
  1332. #endif
  1333. #ifdef    IPPROTO_ICMP
  1334.     insint(d, "IPPROTO_ICMP", IPPROTO_ICMP);
  1335. #endif
  1336. #ifdef    IPPROTO_IGMP
  1337.     insint(d, "IPPROTO_IGMP", IPPROTO_IGMP);
  1338. #endif
  1339. #ifdef    IPPROTO_GGP
  1340.     insint(d, "IPPROTO_GGP", IPPROTO_GGP);
  1341. #endif
  1342. #ifdef    IPPROTO_TCP
  1343.     insint(d, "IPPROTO_TCP", IPPROTO_TCP);
  1344. #endif
  1345. #ifdef    IPPROTO_EGP
  1346.     insint(d, "IPPROTO_EGP", IPPROTO_EGP);
  1347. #endif
  1348. #ifdef    IPPROTO_PUP
  1349.     insint(d, "IPPROTO_PUP", IPPROTO_PUP);
  1350. #endif
  1351. #ifdef    IPPROTO_UDP
  1352.     insint(d, "IPPROTO_UDP", IPPROTO_UDP);
  1353. #endif
  1354. #ifdef    IPPROTO_IDP
  1355.     insint(d, "IPPROTO_IDP", IPPROTO_IDP);
  1356. #endif
  1357. #ifdef    IPPROTO_HELLO
  1358.     insint(d, "IPPROTO_HELLO", IPPROTO_HELLO);
  1359. #endif
  1360. #ifdef    IPPROTO_ND
  1361.     insint(d, "IPPROTO_ND", IPPROTO_ND);
  1362. #endif
  1363. #ifdef    IPPROTO_TP
  1364.     insint(d, "IPPROTO_TP", IPPROTO_TP);
  1365. #endif
  1366. #ifdef    IPPROTO_XTP
  1367.     insint(d, "IPPROTO_XTP", IPPROTO_XTP);
  1368. #endif
  1369. #ifdef    IPPROTO_EON
  1370.     insint(d, "IPPROTO_EON", IPPROTO_EON);
  1371. #endif
  1372. #ifdef    IPPROTO_BIP
  1373.     insint(d, "IPPROTO_BIP", IPPROTO_BIP);
  1374. #endif
  1375. /**/
  1376. #ifdef    IPPROTO_RAW
  1377.     insint(d, "IPPROTO_RAW", IPPROTO_RAW);
  1378. #endif
  1379. #ifdef    IPPROTO_MAX
  1380.     insint(d, "IPPROTO_MAX", IPPROTO_MAX);
  1381. #endif
  1382.  
  1383.     /* Some port configuration */
  1384. #ifdef    IPPORT_RESERVED
  1385.     insint(d, "IPPORT_RESERVED", IPPORT_RESERVED);
  1386. #else
  1387.     insint(d, "IPPORT_RESERVED", 1024);
  1388. #endif
  1389. #ifdef    IPPORT_USERRESERVED
  1390.     insint(d, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
  1391. #else
  1392.     insint(d, "IPPORT_USERRESERVED", 5000);
  1393. #endif
  1394.  
  1395.     /* Some reserved IP v.4 addresses */
  1396. #ifdef    INADDR_ANY
  1397.     insint(d, "INADDR_ANY", INADDR_ANY);
  1398. #else
  1399.     insint(d, "INADDR_ANY", 0x00000000);
  1400. #endif
  1401. #ifdef    INADDR_BROADCAST
  1402.     insint(d, "INADDR_BROADCAST", INADDR_BROADCAST);
  1403. #else
  1404.     insint(d, "INADDR_BROADCAST", 0xffffffff);
  1405. #endif
  1406. #ifdef    INADDR_LOOPBACK
  1407.     insint(d, "INADDR_LOOPBACK", INADDR_LOOPBACK);
  1408. #else
  1409.     insint(d, "INADDR_LOOPBACK", 0x7F000001);
  1410. #endif
  1411. #ifdef    INADDR_UNSPEC_GROUP
  1412.     insint(d, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
  1413. #else
  1414.     insint(d, "INADDR_UNSPEC_GROUP", 0xe0000000);
  1415. #endif
  1416. #ifdef    INADDR_ALLHOSTS_GROUP
  1417.     insint(d, "INADDR_ALLHOSTS_GROUP", INADDR_ALLHOSTS_GROUP);
  1418. #else
  1419.     insint(d, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
  1420. #endif
  1421. #ifdef    INADDR_MAX_LOCAL_GROUP
  1422.     insint(d, "INADDR_MAX_LOCAL_GROUP", INADDR_MAX_LOCAL_GROUP);
  1423. #else
  1424.     insint(d, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
  1425. #endif
  1426. #ifdef    INADDR_NONE
  1427.     insint(d, "INADDR_NONE", INADDR_NONE);
  1428. #else
  1429.     insint(d, "INADDR_NONE", 0xffffffff);
  1430. #endif
  1431.  
  1432.     /* IP [gs]etsockopt options */
  1433. #ifdef    IP_OPTIONS
  1434.     insint(d, "IP_OPTIONS", IP_OPTIONS);
  1435. #endif
  1436. #ifdef    IP_HDRINCL
  1437.     insint(d, "IP_HDRINCL", IP_HDRINCL);
  1438. #endif
  1439. #ifdef    IP_TOS
  1440.     insint(d, "IP_TOS", IP_TOS);
  1441. #endif
  1442. #ifdef    IP_TTL
  1443.     insint(d, "IP_TTL", IP_TTL);
  1444. #endif
  1445. #ifdef    IP_RECVOPTS
  1446.     insint(d, "IP_RECVOPTS", IP_RECVOPTS);
  1447. #endif
  1448. #ifdef    IP_RECVRETOPTS
  1449.     insint(d, "IP_RECVRETOPTS", IP_RECVRETOPTS);
  1450. #endif
  1451. #ifdef    IP_RECVDSTADDR
  1452.     insint(d, "IP_RECVDSTADDR", IP_RECVDSTADDR);
  1453. #endif
  1454. #ifdef    IP_RETOPTS
  1455.     insint(d, "IP_RETOPTS", IP_RETOPTS);
  1456. #endif
  1457. #ifdef    IP_MULTICAST_IF
  1458.     insint(d, "IP_MULTICAST_IF", IP_MULTICAST_IF);
  1459. #endif
  1460. #ifdef    IP_MULTICAST_TTL
  1461.     insint(d, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
  1462. #endif
  1463. #ifdef    IP_MULTICAST_LOOP
  1464.     insint(d, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
  1465. #endif
  1466. #ifdef    IP_ADD_MEMBERSHIP
  1467.     insint(d, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
  1468. #endif
  1469. #ifdef    IP_DROP_MEMBERSHIP
  1470.     insint(d, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
  1471. #endif
  1472. }
  1473.  
  1474. #ifdef NT
  1475. BOOL    WINAPI    DllMain (HANDLE hInst, 
  1476.             ULONG ul_reason_for_call,
  1477.             LPVOID lpReserved)
  1478. {
  1479.     const int opt = SO_SYNCHRONOUS_NONALERT;
  1480.     switch (ul_reason_for_call)
  1481.     {
  1482.         case DLL_PROCESS_ATTACH: {
  1483.             WSADATA WSAData;
  1484.             BOOL ok = TRUE;
  1485.             char buf[100] = "Python can't initialize Windows Sockets Module!\n\r";
  1486.             if (WSAStartup(MAKEWORD(1,1), &WSAData)) {
  1487.                 wsprintf(buf+strlen(buf), "WSAStartup failed (%d)",WSAGetLastError());
  1488.                 ok = FALSE;
  1489.             }
  1490.             /*
  1491.             ** Setup sockets in non-overlapped mode by default
  1492.             */
  1493.             if (ok && setsockopt(INVALID_SOCKET,SOL_SOCKET,SO_OPENTYPE,(const char *)&opt,sizeof(opt)) != 0) {
  1494.                 wsprintf(buf+strlen(buf),"setsockopt failed (%d)",WSAGetLastError());
  1495.                 ok = FALSE;
  1496.             }
  1497.             if (!ok) {
  1498.                 MessageBox(NULL,buf,"WinSock Error",MB_OK|MB_SETFOREGROUND);
  1499.                 return FALSE;
  1500.             }
  1501.             break;
  1502.         }
  1503.  
  1504.         case DLL_PROCESS_DETACH:
  1505.             WSACleanup();
  1506.             break;
  1507.  
  1508.     }
  1509.     return TRUE;
  1510. }
  1511. #endif /* NT */
  1512.